Unit Uvenda;
Interface  Uses Tipos,UniPro,Dos;
           Procedure  AbreArqVenda(Var Vendas:TlistaVenda);
           Procedure  AtuArqVenda(Vendas:TlistaVenda);
           Function   PesqItem(Var Produtos:TlistaPro;Var Produto:Tproduto):Integer;
           Function   RetiraEstoque(Var Produtos:TlistaPro; Item:Titem):Integer;
           Function   CadItem(Var Produtos:TlistaPro;Var Vendas:TlistaVenda;Var Venda:Tvenda; Item:Titem):Integer;
           Function   CadVendedorVenda(Vendedores:TlistaVend;Var Vendedor:Tvendedor; Var Venda:Tvenda):Integer;
           Function   CadClienteVenda(Clientes:TlistaCli;Var Cliente:Tcliente; Var Venda:Tvenda):Integer;
           Function   CadVenda(Var Vendas:TlistaVenda; Var Venda:Tvenda):Integer;
           Procedure  LimpaVenda(Var Venda:Tvenda);
           Procedure  DestroiVendas(Var Vendas:TListaVenda);

Implementation

{Operacoes com arquivo de vendas_____________________________________________}
{Abrindo arquivo de vendas}
Procedure  AbreArqVenda(Var Vendas:TlistaVenda);
{Carrega conteudo do arquivo de vendas na lista em memoria}
{Carrega Itens na lista de itens, Inclusive}
Var
  Cont:Integer;
  Cont2:Integer;
  Arquivo:Text;

Begin
  Vendas.Qtd:=0; {Zerando variavel}
  Cont:=Low(Vendas.C);

  With Vendas.C[1] Do
  Begin
    Cont2:=Low(Itens);
  End;
  Vendas.Qtd:=0;{Zerando quantia de vendasna lista de vendas}

  {abrindo arquivo}
  Assign (Arquivo,'Avenda.TMP');{Variavel assume o arquivo de clientes}

  {$I-}
  Reset(Arquivo);
  {$I+}

  If Ioresult<>0 Then
  Begin
    Rewrite(Arquivo);
    Reset(Arquivo);
  End
  Else
  Begin
    {Lendo de arquivo para vetor}
    While Not(EOF(Arquivo)) Do
    Begin
      With Vendas.C[Cont] Do
      Begin
        Inc(Vendas.Qtd);{Incrementando qtd de vendas da lista}
        Readln(Arquivo,Vendedor.CodVend);
        Readln(Arquivo,Vendedor.NomeVend);
        Readln(Arquivo,Cliente.CodCli);
        Readln(Arquivo,Cliente.NomeCli);
        Readln(Arquivo,DataVend);
        Readln(Arquivo,Itens[Cont2].CodPro);
          While Itens[Cont2].CodPro<>'XXXXX' Do
          Begin
            Inc(Qtd);{Incrementando qtd de itens na lista}
            Readln(Arquivo,Itens[Cont2].QtdItem);
            Inc(Cont2);{Passando para proxima posicao de itens na lista de itens}
            Readln(Arquivo,Itens[Cont2].CodPro);
          End;
          Inc(Cont);{Posicionando-se na proxima venda da lista}
          With Vendas.C[Cont] Do
          Begin{"zerando" Posicao do vetor de itens}
            Cont2:=Low(Itens);
          End;
      End;
    End;
  End;
  Close(Arquivo); {Fechando Arquivo de Vendas}
End;

{Atualizando arquivo de vendas}
Procedure  AtuArqVenda(Vendas:TlistaVenda);
Var
  Arquivo:Text;
  Cont,Cont2:Integer;
Begin
  Assign(Arquivo,'Avenda.TMP');
  Rewrite(Arquivo);
  Append(Arquivo);

    For Cont:=Low(Vendas.C) To Vendas.Qtd Do
    Begin
      With Vendas.C[Cont] Do
      Begin
        Writeln(Arquivo,Vendedor.CodVend:Length(Vendedor.CodVend));
        Writeln(Arquivo,Vendedor.NomeVend:Length(Vendedor.NomeVend));
        Writeln(Arquivo,Cliente.CodCLi:Length(Cliente.CodCLi));
        Writeln(Arquivo,Cliente.NomeCLi:Length(Cliente.NomeCLi));
        Writeln(Arquivo,DataVend:10);
          For Cont2:=Low(Itens) To Qtd  Do
          Begin{Navegando no vetor de itens da venda especifica}
            With Itens[Cont2] Do
            Begin
              Writeln(Arquivo,CodPro:Length(CodPro));
            End;
              Writeln(Arquivo,Itens[Cont2].QtdItem:5);
          End;
          Writeln(Arquivo,'XXXXX');
          {Marcando o fim da lista de itens em arquivo}
      End;
    End;
    Close(Arquivo);{Fechando arquivo de vendas}
End;
{Fim de operacoes com arquivo de vendas______________________________________}

Function PesqItem(Var Produtos:TlistaPro;Var Produto:Tproduto):Integer;
{Tem a finalidade de checar a existencia do item na lista de produtos}
{Fornece uma maneira de pesquisar um item, atraves de seu codigo de}
{produto, na lista de produtos}
Begin
  PesqItem:=PesqPro(Produtos,Produto);{Resultado de pesquisa em produtos}
End;

Function RetiraEstoque(Var Produtos:TlistaPro; Item:Titem):Integer;
{Retira do estoque a quantidade de itens de produto equivalente,}
{Caso condicoes sejam satisfeitas}
{Retorna codigo de sucesso ou insucessos}
{1-sucesso;}
{5-Retirada > estoque}
{6-Estoque vazio}
Begin
  With Produtos Do
  Begin
    If C[Pos].QtdEstoquePro<>0 Then
    Begin
      If C[Pos].QtdEstoquePro>=Item.QtdItem Then
      Begin
        C[Pos].QtdEstoquePro:=C[Pos].QtdEstoquePro-Item.QtdItem;
        RetiraEstoque:=1{Sucesso}
      End
      Else
      Begin
        RetiraEstoque:=5{Retirada maior que estoque}
      End;
    End
    Else
    Begin
      RetiraEstoque:=6{Estoque vazio}
    End;
  End;
End;

Function JaExisteItem(Var Venda:Tvenda; Item:Titem):Boolean;
Var Cont:Integer;
Begin
  JaexisteItem:=False;
  For Cont:=1 To Venda.Qtd Do
  Begin
    If Venda.Itens[Cont].CodPro=Item.CodPro Then
    Begin
      Venda.Itens[Cont].QtdItem:=Venda.Itens[Cont].QtdItem+Item.QtdItem;
      JaExisteItem:=True;
      Break;
    End;
  End;
End;


Function CadItem(Var Produtos:TlistaPro;Var Vendas:TlistaVenda;Var Venda:Tvenda; Item:Titem):Integer;
{Cadastra o item, se tudo for favoravel}
Var
  Produto:Tproduto;
  Result,Result2:Integer;
Begin
{Passos:}
{Se pode efetuar nova venda, entao}
{Se o item e produto cadastrado, entao}
{Se retirar do estoque OK, entao}
{Cadastre item}

  If Vendas.Qtd>=MaxVendas Then{A lista de vendas nao pode estar cheia}
  Begin
    CadItem:=2{Codigo para lista de vendas cheia}
  End
  Else
  Begin
    Produto.CodPro:=Item.CodPro;
    Result:=PesqItem(Produtos,Produto);{Saber se e um produto cadastrado}
                                          {Retorno de codigos uteis}
    Case Result Of
    1:Begin{Caso o item seja produto cadastrado}
        Result2:=RetiraEstoque(Produtos,Item);{Dira se retirada/estoque teve sucesso ou nao}
        If Result2=1 Then
        Begin
          If Not JaExisteItem(Venda,Item) Then
          {Se item ja esta na lista de itens, basta atualizar quantidade}
          Begin
            If Result2<>6 Then
            Begin{Nao se pode vender nada}
              Inc(Venda.Qtd);{Incrementa qtd de itens na lista de itens em venda}
              Venda.Itens[Venda.Qtd]:=Item;{Inserindo item na lista de item}
              CadItem:=1;{Sucesso}
            End;
          End
          Else
          Begin
            CadItem:=1;{Item ja existe, qtd atualizada, sucesso.}
          End;
        End
        Else{Caso haja retirada maior que estoque(5) ou sem estoque(6)}
        Begin
          CadItem:=Result2;
        End;
      End;
    2:Begin
        CadItem:=3;{Lista vazia, produto inexistente}
      End;
    3,4:Begin
          CadItem:=Result{Sendo 3 p/ inexistente e 4 p/ codigo invalido}
        End;
    End;
  End;
End;

Function  CadVendedorVenda(Vendedores:TlistaVend;Var Vendedor:Tvendedor; Var Venda:Tvenda):Integer;
{Cadastra um vendedor na venda}
{Basta ter o codigo de vendedor}
{Codigos de erro/acerto retornados:}
{1-Sucesso; 2-Lista de vendedores vazia; 3-Vendedor inexistente;}
{4-Codigo invalido; 5-Sem itens,sem venda para cadastrar qualquer vendedor}
Var
  Result:Integer;
Begin
  If Venda.Qtd<>0 Then{Nao pode haver um vendedor sem venda de qualquer item}
  Begin
    Result:=PesqVend(Vendedores,Vendedor); {Basta ter o codigo do vendedor}
    If Result=1 Then
    Begin{Cadastrando vendedor}
      Venda.Vendedor:=Vendedor;
    End;
  End
  Else
  Begin
    CadVendedorVenda:=5;{Lista de itens vazia}
  End;
  CadVendedorVenda:=Result;
End;

Function  CadClienteVenda(Clientes:TlistaCli;Var Cliente:Tcliente; Var Venda:Tvenda):Integer;
{Cadastra um cliente na venda}
{Basta ter o codigo de cliente}
{Codigos de erro/acerto retornados:}
{1-Sucesso; 2-Lista de clientes vazia; 3-Cliente inexistente;}
{4-Codigo invalido; 5-Sem itens,sem venda para cadastrar qualquer cliente}
Var
  Result:Integer;
Begin
  If Venda.Qtd<>0 Then{Nao pode haver um cliente sem venda de qualquer item}
  Begin
    Result:=PesqCli(Clientes,Cliente);{Basta ter o codigo do cliente}
    If Result=1 Then
    Begin{Cadastrando cliente}
      Venda.Cliente:=Cliente;
    End;
  End
  Else
  Begin
    CadClienteVenda:=5;{Lista de itens vazia}
  End;
  CadClienteVenda:=Result;
End;


Function CadVenda(Var Vendas:TlistaVenda;Var Venda:Tvenda):Integer;
{Cadastra a venda na lista de vendas}
{Retorna 3 codigos}
{1-Sucesso; 2-Sem vendedor; 3-Sem Cliente;}
Type
  DataWord=Record
             Ano,Mes,Dia,DiaDaSemana: Word;
           End;
  DataString=Record
               Ano,Mes,Dia:String;
             End;

Var
  Data:DataWord;{Recebera a data atual em formato numerico}
  Data2:Datastring;{Contera a data atual como string}

Begin

  If Venda.Vendedor.CodVend<>'' Then
  Begin{Nao pode haver venda sem vendedor e cliente}
    If Venda.Cliente.CodCli<>'' Then
    Begin
      With Data Do
      Begin
        GetDate(Ano,Mes,Dia,DiaDaSemana);
        STR(Dia,Data2.Dia);
        STR(Mes,Data2.Mes);
        STR(Ano,Data2.Ano);
        Venda.DataVend:=Data2.Dia+'/'+Data2.Mes+'/'+Data2.Ano;
      End;
      Inc(Vendas.Qtd);{Lista de vendas e incrementada}
      Vendas.C[Vendas.Qtd]:=Venda;{Inserindo venda na lista de vendas}
      CadVenda:=1;
      LimpaVenda(Venda);{Limpando a venda temporaria}
    End
    Else
    Begin
      CadVenda:=3;{Sem cliente}
    End;
  End
  Else
  Begin
    CadVenda:=2{Sem vendedor}
  End;
End;

Procedure  LimpaVenda(Var Venda:Tvenda);
Var{Limpa a venda temporaria}
  Cont:Integer;
Begin
  With Venda Do
  Begin
    Qtd:=0;{Zerando quantidade da lista de itens}
    Cliente.CodCLi:='';{Limpando os outros campos}
    Cliente.NomeCLi:='';
    Vendedor.CodVend:='';
    Vendedor.NomeVend:='';
    DataVend:='';
  End;
End;

Procedure DestroiVendas(Var Vendas:TlistaVenda);
{Destroi a lista de vendas}
Begin
  Vendas.Qtd:=0;
End;

End.{Fim da Unit}